#!/usr/bin/env python3
"""
独立日志模块 - 完全独立的日志系统，不受Python logging影响
"""

import sys
import os
from datetime import datetime
from enum import Enum

class LogLevel(Enum):
    """日志级别枚举"""
    DEBUG = 0
    INFO = 1
    WARNING = 2
    ERROR = 3
    CRITICAL = 4

class IndependentLogger:
    """完全独立的日志器，不依赖Python logging系统"""
    
    def __init__(self, name="comfyui_lora_train", level=LogLevel.DEBUG, factory=None):
        """初始化独立日志器
        Args:
            name: 日志器名称
            level: 日志级别
            factory: 日志工厂实例
        """
        self.name = name
        self.level = level
        self.output_stream = sys.stdout
        self.factory = factory
    
    def _should_log(self, message_level):
        """检查是否应该输出日志
        先判断总控级别，再判断logger自己的级别
        """
        # 首先判断总控级别
        if self.factory and message_level.value < self.factory.get_global_level().value:
            return False
        
        # 然后判断logger自己的级别
        return message_level.value >= self.level.value
    
    def _format_message(self, level_name, message):
        """格式化日志消息"""
        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
        return f"{timestamp} - {self.name} - {level_name} - {message}"
    
    def _log(self, level_name, message, level_enum):
        """内部日志方法"""
        if self._should_log(level_enum):
            formatted_message = self._format_message(level_name, message)
            print(formatted_message, file=self.output_stream, flush=True)
    
    def debug(self, message):
        """输出DEBUG级别日志"""
        self._log("DEBUG", message, LogLevel.DEBUG)
    
    def info(self, message):
        """输出INFO级别日志"""
        self._log("INFO", message, LogLevel.INFO)
    
    def warning(self, message):
        """输出WARNING级别日志"""
        self._log("WARNING", message, LogLevel.WARNING)
    
    def error(self, message):
        """输出ERROR级别日志"""
        self._log("ERROR", message, LogLevel.ERROR)
    
    def critical(self, message):
        """输出CRITICAL级别日志"""
        self._log("CRITICAL", message, LogLevel.CRITICAL)
    
    def set_level(self, level):
        """设置日志级别"""
        if isinstance(level, str):
            level = LogLevel[level.upper()]
        self.level = level
    
    def set_output_stream(self, stream):
        """设置输出流"""
        self.output_stream = stream

# 为了兼容性，创建一个logger对象
class LoggerWrapper:
    """兼容Python logging的包装器"""
    
    def __init__(self, logger):
        self.logger = logger
    
    def debug(self, message, *args, **kwargs):
        self.logger.debug(message)
    
    def info(self, message, *args, **kwargs):
        self.logger.info(message)
    
    def warning(self, message, *args, **kwargs):
        self.logger.warning(message)
    
    def error(self, message, *args, **kwargs):
        self.logger.error(message)
    
    def critical(self, message, *args, **kwargs):
        self.logger.critical(message)

class LoggerFactory:
    """日志工厂 - 管理每个脚本的logger实例"""
    
    def __init__(self):
        self._loggers = {}
        self._global_level = LogLevel.DEBUG  # 全局默认级别
    
    def get_logger(self, name=None, level=None):
        """获取或创建logger实例
        Args:
            name: logger名称，如果为None则自动生成
            level: 日志级别，如果为None则使用全局级别
        Returns:
            LoggerWrapper: 包装的logger实例
        """
        if name is None:
            # 自动生成名称
            import inspect
            frame = inspect.currentframe()
            if frame and frame.f_back and frame.f_back.f_back:
                module_name = frame.f_back.f_back.f_globals.get('__name__', 'unknown')
                name = f"{module_name}_logger"
            else:
                name = "default_logger"
        
        if name not in self._loggers:
            # 如果没有指定级别，使用全局级别
            if level is None:
                level = self._global_level
            
            # 创建新的logger实例，传入工厂引用
            independent_logger = IndependentLogger(name, level, self)
            self._loggers[name] = LoggerWrapper(independent_logger)
        else:
            # 如果logger已存在，更新其级别
            if level is not None:
                self._loggers[name].logger.set_level(level)
        
        return self._loggers[name]
    
    def set_global_level(self, level):
        """设置全局日志级别，影响所有logger
        Args:
            level: 日志级别（LogLevel枚举或字符串）
        """
        if isinstance(level, str):
            level = LogLevel[level.upper()]
        self._global_level = level
    
    def get_global_level(self):
        """获取全局日志级别"""
        return self._global_level
    
    def set_logger_level(self, name, level):
        """设置指定logger的级别"""
        if name in self._loggers:
            wrapper = self._loggers[name]
            wrapper.logger.set_level(level)
    
    def get_all_loggers(self):
        """获取所有logger名称"""
        return list(self._loggers.keys())
    
    def get_logger_info(self):
        """获取所有logger的详细信息"""
        info = {}
        for name, wrapper in self._loggers.items():
            info[name] = {
                'level': wrapper.logger.level.name,
                'name': wrapper.logger.name,
                'global_level': self._global_level.name
            }
        return info

# 创建全局工厂实例
logger_factory = LoggerFactory()

# 便捷函数 - 获取当前模块的logger
def get_logger(name=None, level=None):
    """获取logger实例的便捷函数"""
    return logger_factory.get_logger(name, level)

# 全局控制函数
def set_global_level(level):
    """设置全局日志级别
    Args:
        level: 日志级别（字符串：'DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'）
    """
    logger_factory.set_global_level(level)

def get_global_level():
    """获取全局日志级别"""
    return logger_factory.get_global_level()

def set_logger_level(name, level):
    """设置指定logger的级别"""
    logger_factory.set_logger_level(name, level)

def get_all_loggers():
    """获取所有logger名称"""
    return logger_factory.get_all_loggers()

def get_logger_info():
    """获取所有logger的详细信息"""
    return logger_factory.get_logger_info()

# 为了向后兼容，创建一个默认logger（不推荐使用）
def _create_default_logger():
    """创建默认logger（仅用于向后兼容）"""
    return logger_factory.get_logger("default")

# 导出默认logger（不推荐使用，建议使用get_logger()）
logger = _create_default_logger()

# 使用示例：
# 
# 1. 设置全局日志级别（影响所有logger）
# from .custom_logger import set_global_level
# set_global_level('DEBUG')  # 显示所有日志
# set_global_level('INFO')   # 只显示INFO及以上级别
# set_global_level('WARNING') # 只显示WARNING及以上级别
# 
# 2. 获取当前模块的logger
# from .custom_logger import get_logger
# logger = get_logger()  # 自动使用模块名
# logger = get_logger("my_module")  # 手动指定名称
# 
# 3. 设置特定logger的级别
# from .custom_logger import set_logger_level
# set_logger_level("base_trainer_api", "DEBUG")
# 
# 4. 查看所有logger信息
# from .custom_logger import get_logger_info
# print(get_logger_info())
# 
# 5. 在训练开始时设置全局级别
# set_global_level('DEBUG')  # 显示所有调试信息
# 
# 6. 在训练完成后设置全局级别
# set_global_level('INFO')   # 只显示重要信息 